// $ANTLR 3.1.3 Mar 18, 2009 10:09:25 YaplLexer.g 2011-04-26 20:05:24


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;


namespace  YAPL.Language.SourceParser.Antlr 
{
public class YaplLexer : Lexer {
    public const int DOLLAR = 38;
    public const int CLASS = 12;
    public const int WHILE = 13;
    public const int MOD = 26;
    public const int LETTER = 34;
    public const int INSTANCE_NAME = 39;
    public const int FLOAT = 31;
    public const int NOT = 29;
    public const int AND = 27;
    public const int EOF = -1;
    public const int SPACE = 43;
    public const int FALSE_C = 17;
    public const int IF = 14;
    public const int RET = 11;
    public const int RIGHT_PAREN = 6;
    public const int NAME = 37;
    public const int STRING_LITERAL = 41;
    public const int MULTIPLY = 24;
    public const int COMMA = 18;
    public const int PLUS = 23;
    public const int DIGIT = 35;
    public const int DOT = 19;
    public const int DIVIDE = 25;
    public const int RIGHT_BRACE = 8;
    public const int INTEGER = 30;
    public const int BOOL_C = 32;
    public const int CLASS_NAME = 36;
    public const int SYMBOL = 42;
    public const int ELSE = 15;
    public const int WHITESPACE = 45;
    public const int MINUS = 22;
    public const int DECREMENT = 20;
    public const int INCREMENT = 21;
    public const int NEWLINE = 46;
    public const int NONCONTROL_CHAR = 40;
    public const int FUNC = 9;
    public const int LEFT_BRACE = 7;
    public const int OR = 28;
    public const int ASSIGN = 4;
    public const int LEFT_PAREN = 5;
    public const int TRUE_C = 16;
    public const int LOWER = 44;
    public const int END = 10;
    public const int UPPER = 33;

    // delegates
    // delegators

    public YaplLexer() 
    {
		InitializeCyclicDFAs();
    }
    public YaplLexer(ICharStream input)
		: this(input, null) {
    }
    public YaplLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state) {
		InitializeCyclicDFAs(); 

    }
    
    override public string GrammarFileName
    {
    	get { return "YaplLexer.g";} 
    }

    // $ANTLR start "ASSIGN"
    public void mASSIGN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ASSIGN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:10:7: ( '=' )
            // YaplLexer.g:10:9: '='
            {
            	Match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ASSIGN"

    // $ANTLR start "LEFT_PAREN"
    public void mLEFT_PAREN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = LEFT_PAREN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:12:11: ( '(' )
            // YaplLexer.g:12:13: '('
            {
            	Match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "LEFT_PAREN"

    // $ANTLR start "RIGHT_PAREN"
    public void mRIGHT_PAREN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = RIGHT_PAREN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:13:12: ( ')' )
            // YaplLexer.g:13:14: ')'
            {
            	Match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "RIGHT_PAREN"

    // $ANTLR start "LEFT_BRACE"
    public void mLEFT_BRACE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = LEFT_BRACE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:15:11: ( '{' )
            // YaplLexer.g:15:13: '{'
            {
            	Match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "LEFT_BRACE"

    // $ANTLR start "RIGHT_BRACE"
    public void mRIGHT_BRACE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = RIGHT_BRACE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:16:12: ( '}' )
            // YaplLexer.g:16:14: '}'
            {
            	Match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "RIGHT_BRACE"

    // $ANTLR start "FUNC"
    public void mFUNC() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = FUNC;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:17:5: ( 'func' )
            // YaplLexer.g:17:7: 'func'
            {
            	Match("func"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "FUNC"

    // $ANTLR start "END"
    public void mEND() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = END;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:18:4: ( 'end' )
            // YaplLexer.g:18:6: 'end'
            {
            	Match("end"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "END"

    // $ANTLR start "RET"
    public void mRET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = RET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:19:4: ( 'ret' )
            // YaplLexer.g:19:6: 'ret'
            {
            	Match("ret"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "RET"

    // $ANTLR start "CLASS"
    public void mCLASS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CLASS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:20:6: ( 'class' )
            // YaplLexer.g:20:8: 'class'
            {
            	Match("class"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CLASS"

    // $ANTLR start "WHILE"
    public void mWHILE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WHILE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:21:6: ( 'while' )
            // YaplLexer.g:21:8: 'while'
            {
            	Match("while"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "WHILE"

    // $ANTLR start "IF"
    public void mIF() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = IF;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:22:3: ( 'if' )
            // YaplLexer.g:22:5: 'if'
            {
            	Match("if"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "IF"

    // $ANTLR start "ELSE"
    public void mELSE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ELSE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:23:5: ( 'else' )
            // YaplLexer.g:23:7: 'else'
            {
            	Match("else"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ELSE"

    // $ANTLR start "TRUE_C"
    public void mTRUE_C() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:24:16: ( 'true' )
            // YaplLexer.g:24:18: 'true'
            {
            	Match("true"); 


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "TRUE_C"

    // $ANTLR start "FALSE_C"
    public void mFALSE_C() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:25:17: ( 'false' )
            // YaplLexer.g:25:19: 'false'
            {
            	Match("false"); 


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "FALSE_C"

    // $ANTLR start "COMMA"
    public void mCOMMA() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = COMMA;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:26:6: ( ',' )
            // YaplLexer.g:26:8: ','
            {
            	Match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "DOT"
    public void mDOT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DOT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:27:4: ( '.' )
            // YaplLexer.g:27:6: '.'
            {
            	Match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DOT"

    // $ANTLR start "DECREMENT"
    public void mDECREMENT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DECREMENT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:31:10: ( '--' )
            // YaplLexer.g:31:12: '--'
            {
            	Match("--"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DECREMENT"

    // $ANTLR start "INCREMENT"
    public void mINCREMENT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = INCREMENT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:32:10: ( '++' )
            // YaplLexer.g:32:12: '++'
            {
            	Match("++"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "INCREMENT"

    // $ANTLR start "MINUS"
    public void mMINUS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = MINUS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:33:6: ( '-' )
            // YaplLexer.g:33:8: '-'
            {
            	Match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "PLUS"
    public void mPLUS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = PLUS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:34:5: ( '+' )
            // YaplLexer.g:34:7: '+'
            {
            	Match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MULTIPLY"
    public void mMULTIPLY() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = MULTIPLY;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:35:9: ( '*' )
            // YaplLexer.g:35:11: '*'
            {
            	Match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "MULTIPLY"

    // $ANTLR start "DIVIDE"
    public void mDIVIDE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DIVIDE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:36:7: ( '/' )
            // YaplLexer.g:36:9: '/'
            {
            	Match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DIVIDE"

    // $ANTLR start "MOD"
    public void mMOD() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = MOD;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:37:4: ( '%' )
            // YaplLexer.g:37:6: '%'
            {
            	Match('%'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "MOD"

    // $ANTLR start "AND"
    public void mAND() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = AND;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:39:4: ( '&&' )
            // YaplLexer.g:39:6: '&&'
            {
            	Match("&&"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "OR"
    public void mOR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:40:3: ( '||' )
            // YaplLexer.g:40:5: '||'
            {
            	Match("||"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "NOT"
    public void mNOT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = NOT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:41:4: ( '!' )
            // YaplLexer.g:41:6: '!'
            {
            	Match('!'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "NOT"

    // $ANTLR start "FLOAT"
    public void mFLOAT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = FLOAT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:44:6: ( INTEGER '.' ( '0' .. '9' )+ )
            // YaplLexer.g:44:8: INTEGER '.' ( '0' .. '9' )+
            {
            	mINTEGER(); 
            	Match('.'); 
            	// YaplLexer.g:44:20: ( '0' .. '9' )+
            	int cnt1 = 0;
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( ((LA1_0 >= '0' && LA1_0 <= '9')) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // YaplLexer.g:44:20: '0' .. '9'
            			    {
            			    	MatchRange('0','9'); 

            			    }
            			    break;

            			default:
            			    if ( cnt1 >= 1 ) goto loop1;
            		            EarlyExitException eee1 =
            		                new EarlyExitException(1, input);
            		            throw eee1;
            	    }
            	    cnt1++;
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "FLOAT"

    // $ANTLR start "INTEGER"
    public void mINTEGER() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = INTEGER;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:45:8: ( '0' | '1' .. '9' ( '0' .. '9' )* )
            int alt3 = 2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0 == '0') )
            {
                alt3 = 1;
            }
            else if ( ((LA3_0 >= '1' && LA3_0 <= '9')) )
            {
                alt3 = 2;
            }
            else 
            {
                NoViableAltException nvae_d3s0 =
                    new NoViableAltException("", 3, 0, input);

                throw nvae_d3s0;
            }
            switch (alt3) 
            {
                case 1 :
                    // YaplLexer.g:45:10: '0'
                    {
                    	Match('0'); 

                    }
                    break;
                case 2 :
                    // YaplLexer.g:45:16: '1' .. '9' ( '0' .. '9' )*
                    {
                    	MatchRange('1','9'); 
                    	// YaplLexer.g:45:25: ( '0' .. '9' )*
                    	do 
                    	{
                    	    int alt2 = 2;
                    	    int LA2_0 = input.LA(1);

                    	    if ( ((LA2_0 >= '0' && LA2_0 <= '9')) )
                    	    {
                    	        alt2 = 1;
                    	    }


                    	    switch (alt2) 
                    		{
                    			case 1 :
                    			    // YaplLexer.g:45:25: '0' .. '9'
                    			    {
                    			    	MatchRange('0','9'); 

                    			    }
                    			    break;

                    			default:
                    			    goto loop2;
                    	    }
                    	} while (true);

                    	loop2:
                    		;	// Stops C# compiler whining that label 'loop2' has no statements


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "INTEGER"

    // $ANTLR start "BOOL_C"
    public void mBOOL_C() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = BOOL_C;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:46:7: ( TRUE_C | FALSE_C )
            int alt4 = 2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0 == 't') )
            {
                alt4 = 1;
            }
            else if ( (LA4_0 == 'f') )
            {
                alt4 = 2;
            }
            else 
            {
                NoViableAltException nvae_d4s0 =
                    new NoViableAltException("", 4, 0, input);

                throw nvae_d4s0;
            }
            switch (alt4) 
            {
                case 1 :
                    // YaplLexer.g:46:9: TRUE_C
                    {
                    	mTRUE_C(); 

                    }
                    break;
                case 2 :
                    // YaplLexer.g:46:18: FALSE_C
                    {
                    	mFALSE_C(); 

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "BOOL_C"

    // $ANTLR start "CLASS_NAME"
    public void mCLASS_NAME() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CLASS_NAME;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:47:11: ( UPPER ( LETTER | DIGIT | '_' )* )
            // YaplLexer.g:47:13: UPPER ( LETTER | DIGIT | '_' )*
            {
            	mUPPER(); 
            	// YaplLexer.g:47:19: ( LETTER | DIGIT | '_' )*
            	do 
            	{
            	    int alt5 = 2;
            	    int LA5_0 = input.LA(1);

            	    if ( ((LA5_0 >= '0' && LA5_0 <= '9') || (LA5_0 >= 'A' && LA5_0 <= 'Z') || LA5_0 == '_' || (LA5_0 >= 'a' && LA5_0 <= 'z')) )
            	    {
            	        alt5 = 1;
            	    }


            	    switch (alt5) 
            		{
            			case 1 :
            			    // YaplLexer.g:
            			    {
            			    	if ( (input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    goto loop5;
            	    }
            	} while (true);

            	loop5:
            		;	// Stops C# compiler whining that label 'loop5' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CLASS_NAME"

    // $ANTLR start "NAME"
    public void mNAME() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = NAME;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:48:5: ( ( LETTER | '_' ) ( LETTER | DIGIT | '_' )* )
            // YaplLexer.g:48:7: ( LETTER | '_' ) ( LETTER | DIGIT | '_' )*
            {
            	if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}

            	// YaplLexer.g:48:22: ( LETTER | DIGIT | '_' )*
            	do 
            	{
            	    int alt6 = 2;
            	    int LA6_0 = input.LA(1);

            	    if ( ((LA6_0 >= '0' && LA6_0 <= '9') || (LA6_0 >= 'A' && LA6_0 <= 'Z') || LA6_0 == '_' || (LA6_0 >= 'a' && LA6_0 <= 'z')) )
            	    {
            	        alt6 = 1;
            	    }


            	    switch (alt6) 
            		{
            			case 1 :
            			    // YaplLexer.g:
            			    {
            			    	if ( (input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    goto loop6;
            	    }
            	} while (true);

            	loop6:
            		;	// Stops C# compiler whining that label 'loop6' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "NAME"

    // $ANTLR start "INSTANCE_NAME"
    public void mINSTANCE_NAME() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = INSTANCE_NAME;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:49:14: ( DOLLAR NAME )
            // YaplLexer.g:49:16: DOLLAR NAME
            {
            	mDOLLAR(); 
            	mNAME(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "INSTANCE_NAME"

    // $ANTLR start "STRING_LITERAL"
    public void mSTRING_LITERAL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = STRING_LITERAL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:50:15: ( '\\'' ( NONCONTROL_CHAR )* '\\'' )
            // YaplLexer.g:50:17: '\\'' ( NONCONTROL_CHAR )* '\\''
            {
            	Match('\''); 
            	// YaplLexer.g:50:22: ( NONCONTROL_CHAR )*
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( (LA7_0 == '\t' || (LA7_0 >= ' ' && LA7_0 <= '!') || (LA7_0 >= '#' && LA7_0 <= '&') || (LA7_0 >= '(' && LA7_0 <= '~')) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // YaplLexer.g:50:22: NONCONTROL_CHAR
            			    {
            			    	mNONCONTROL_CHAR(); 

            			    }
            			    break;

            			default:
            			    goto loop7;
            	    }
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements

            	Match('\''); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "STRING_LITERAL"

    // $ANTLR start "NONCONTROL_CHAR"
    public void mNONCONTROL_CHAR() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:52:25: ( LETTER | DIGIT | SYMBOL | SPACE )
            // YaplLexer.g:
            {
            	if ( input.LA(1) == '\t' || (input.LA(1) >= ' ' && input.LA(1) <= '!') || (input.LA(1) >= '#' && input.LA(1) <= '&') || (input.LA(1) >= '(' && input.LA(1) <= '~') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "NONCONTROL_CHAR"

    // $ANTLR start "LETTER"
    public void mLETTER() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:53:16: ( LOWER | UPPER )
            // YaplLexer.g:
            {
            	if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "LETTER"

    // $ANTLR start "LOWER"
    public void mLOWER() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:54:15: ( 'a' .. 'z' )
            // YaplLexer.g:54:17: 'a' .. 'z'
            {
            	MatchRange('a','z'); 

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "LOWER"

    // $ANTLR start "UPPER"
    public void mUPPER() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:55:15: ( 'A' .. 'Z' )
            // YaplLexer.g:55:17: 'A' .. 'Z'
            {
            	MatchRange('A','Z'); 

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "UPPER"

    // $ANTLR start "DIGIT"
    public void mDIGIT() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:56:15: ( '0' .. '9' )
            // YaplLexer.g:56:17: '0' .. '9'
            {
            	MatchRange('0','9'); 

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "DIGIT"

    // $ANTLR start "DOLLAR"
    public void mDOLLAR() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:57:16: ( '$' )
            // YaplLexer.g:57:18: '$'
            {
            	Match('$'); 

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "DOLLAR"

    // $ANTLR start "SPACE"
    public void mSPACE() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:58:15: ( ' ' | '\\t' )
            // YaplLexer.g:
            {
            	if ( input.LA(1) == '\t' || input.LA(1) == ' ' ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "SPACE"

    // $ANTLR start "SYMBOL"
    public void mSYMBOL() // throws RecognitionException [2]
    {
    		try
    		{
            // YaplLexer.g:65:16: ( '!' | '#' .. '&' | '(' .. '/' | ':' .. '@' | '[' .. '`' | '{' .. '~' )
            // YaplLexer.g:
            {
            	if ( input.LA(1) == '!' || (input.LA(1) >= '#' && input.LA(1) <= '&') || (input.LA(1) >= '(' && input.LA(1) <= '/') || (input.LA(1) >= ':' && input.LA(1) <= '@') || (input.LA(1) >= '[' && input.LA(1) <= '`') || (input.LA(1) >= '{' && input.LA(1) <= '~') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "SYMBOL"

    // $ANTLR start "WHITESPACE"
    public void mWHITESPACE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WHITESPACE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:67:11: ( ( SPACE )+ )
            // YaplLexer.g:67:13: ( SPACE )+
            {
            	// YaplLexer.g:67:13: ( SPACE )+
            	int cnt8 = 0;
            	do 
            	{
            	    int alt8 = 2;
            	    int LA8_0 = input.LA(1);

            	    if ( (LA8_0 == '\t' || LA8_0 == ' ') )
            	    {
            	        alt8 = 1;
            	    }


            	    switch (alt8) 
            		{
            			case 1 :
            			    // YaplLexer.g:67:13: SPACE
            			    {
            			    	mSPACE(); 

            			    }
            			    break;

            			default:
            			    if ( cnt8 >= 1 ) goto loop8;
            		            EarlyExitException eee8 =
            		                new EarlyExitException(8, input);
            		            throw eee8;
            	    }
            	    cnt8++;
            	} while (true);

            	loop8:
            		;	// Stops C# compiler whining that label 'loop8' has no statements

            	 _channel = HIDDEN; 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "WHITESPACE"

    // $ANTLR start "NEWLINE"
    public void mNEWLINE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = NEWLINE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // YaplLexer.g:68:8: ( ( ( '\\r' )? '\\n' )+ )
            // YaplLexer.g:68:10: ( ( '\\r' )? '\\n' )+
            {
            	// YaplLexer.g:68:10: ( ( '\\r' )? '\\n' )+
            	int cnt10 = 0;
            	do 
            	{
            	    int alt10 = 2;
            	    int LA10_0 = input.LA(1);

            	    if ( (LA10_0 == '\n' || LA10_0 == '\r') )
            	    {
            	        alt10 = 1;
            	    }


            	    switch (alt10) 
            		{
            			case 1 :
            			    // YaplLexer.g:68:11: ( '\\r' )? '\\n'
            			    {
            			    	// YaplLexer.g:68:11: ( '\\r' )?
            			    	int alt9 = 2;
            			    	int LA9_0 = input.LA(1);

            			    	if ( (LA9_0 == '\r') )
            			    	{
            			    	    alt9 = 1;
            			    	}
            			    	switch (alt9) 
            			    	{
            			    	    case 1 :
            			    	        // YaplLexer.g:68:11: '\\r'
            			    	        {
            			    	        	Match('\r'); 

            			    	        }
            			    	        break;

            			    	}

            			    	Match('\n'); 

            			    }
            			    break;

            			default:
            			    if ( cnt10 >= 1 ) goto loop10;
            		            EarlyExitException eee10 =
            		                new EarlyExitException(10, input);
            		            throw eee10;
            	    }
            	    cnt10++;
            	} while (true);

            	loop10:
            		;	// Stops C# compiler whining that label 'loop10' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "NEWLINE"

    override public void mTokens() // throws RecognitionException 
    {
        // YaplLexer.g:1:8: ( ASSIGN | LEFT_PAREN | RIGHT_PAREN | LEFT_BRACE | RIGHT_BRACE | FUNC | END | RET | CLASS | WHILE | IF | ELSE | COMMA | DOT | DECREMENT | INCREMENT | MINUS | PLUS | MULTIPLY | DIVIDE | MOD | AND | OR | NOT | FLOAT | INTEGER | BOOL_C | CLASS_NAME | NAME | INSTANCE_NAME | STRING_LITERAL | WHITESPACE | NEWLINE )
        int alt11 = 33;
        alt11 = dfa11.Predict(input);
        switch (alt11) 
        {
            case 1 :
                // YaplLexer.g:1:10: ASSIGN
                {
                	mASSIGN(); 

                }
                break;
            case 2 :
                // YaplLexer.g:1:17: LEFT_PAREN
                {
                	mLEFT_PAREN(); 

                }
                break;
            case 3 :
                // YaplLexer.g:1:28: RIGHT_PAREN
                {
                	mRIGHT_PAREN(); 

                }
                break;
            case 4 :
                // YaplLexer.g:1:40: LEFT_BRACE
                {
                	mLEFT_BRACE(); 

                }
                break;
            case 5 :
                // YaplLexer.g:1:51: RIGHT_BRACE
                {
                	mRIGHT_BRACE(); 

                }
                break;
            case 6 :
                // YaplLexer.g:1:63: FUNC
                {
                	mFUNC(); 

                }
                break;
            case 7 :
                // YaplLexer.g:1:68: END
                {
                	mEND(); 

                }
                break;
            case 8 :
                // YaplLexer.g:1:72: RET
                {
                	mRET(); 

                }
                break;
            case 9 :
                // YaplLexer.g:1:76: CLASS
                {
                	mCLASS(); 

                }
                break;
            case 10 :
                // YaplLexer.g:1:82: WHILE
                {
                	mWHILE(); 

                }
                break;
            case 11 :
                // YaplLexer.g:1:88: IF
                {
                	mIF(); 

                }
                break;
            case 12 :
                // YaplLexer.g:1:91: ELSE
                {
                	mELSE(); 

                }
                break;
            case 13 :
                // YaplLexer.g:1:96: COMMA
                {
                	mCOMMA(); 

                }
                break;
            case 14 :
                // YaplLexer.g:1:102: DOT
                {
                	mDOT(); 

                }
                break;
            case 15 :
                // YaplLexer.g:1:106: DECREMENT
                {
                	mDECREMENT(); 

                }
                break;
            case 16 :
                // YaplLexer.g:1:116: INCREMENT
                {
                	mINCREMENT(); 

                }
                break;
            case 17 :
                // YaplLexer.g:1:126: MINUS
                {
                	mMINUS(); 

                }
                break;
            case 18 :
                // YaplLexer.g:1:132: PLUS
                {
                	mPLUS(); 

                }
                break;
            case 19 :
                // YaplLexer.g:1:137: MULTIPLY
                {
                	mMULTIPLY(); 

                }
                break;
            case 20 :
                // YaplLexer.g:1:146: DIVIDE
                {
                	mDIVIDE(); 

                }
                break;
            case 21 :
                // YaplLexer.g:1:153: MOD
                {
                	mMOD(); 

                }
                break;
            case 22 :
                // YaplLexer.g:1:157: AND
                {
                	mAND(); 

                }
                break;
            case 23 :
                // YaplLexer.g:1:161: OR
                {
                	mOR(); 

                }
                break;
            case 24 :
                // YaplLexer.g:1:164: NOT
                {
                	mNOT(); 

                }
                break;
            case 25 :
                // YaplLexer.g:1:168: FLOAT
                {
                	mFLOAT(); 

                }
                break;
            case 26 :
                // YaplLexer.g:1:174: INTEGER
                {
                	mINTEGER(); 

                }
                break;
            case 27 :
                // YaplLexer.g:1:182: BOOL_C
                {
                	mBOOL_C(); 

                }
                break;
            case 28 :
                // YaplLexer.g:1:189: CLASS_NAME
                {
                	mCLASS_NAME(); 

                }
                break;
            case 29 :
                // YaplLexer.g:1:200: NAME
                {
                	mNAME(); 

                }
                break;
            case 30 :
                // YaplLexer.g:1:205: INSTANCE_NAME
                {
                	mINSTANCE_NAME(); 

                }
                break;
            case 31 :
                // YaplLexer.g:1:219: STRING_LITERAL
                {
                	mSTRING_LITERAL(); 

                }
                break;
            case 32 :
                // YaplLexer.g:1:234: WHITESPACE
                {
                	mWHITESPACE(); 

                }
                break;
            case 33 :
                // YaplLexer.g:1:245: NEWLINE
                {
                	mNEWLINE(); 

                }
                break;

        }

    }


    protected DFA11 dfa11;
	private void InitializeCyclicDFAs()
	{
	    this.dfa11 = new DFA11(this);
	}

    const string DFA11_eotS =
        "\x06\uffff\x06\x1a\x02\uffff\x01\x28\x01\x2a\x06\uffff\x02\x2b"+
        "\x01\x1a\x01\x2f\x05\uffff\x07\x1a\x01\x38\x06\uffff\x01\x2b\x01"+
        "\x1a\x01\uffff\x01\x2f\x02\x1a\x01\x3c\x01\x1a\x01\x3e\x02\x1a\x01"+
        "\uffff\x01\x1a\x01\x42\x01\x1a\x01\uffff\x01\x44\x01\uffff\x02\x1a"+
        "\x01\x47\x01\uffff\x01\x47\x01\uffff\x01\x48\x01\x49\x03\uffff";
    const string DFA11_eofS =
        "\x4a\uffff";
    const string DFA11_minS =
        "\x01\x09\x05\uffff\x01\x61\x01\x6c\x01\x65\x01\x6c\x01\x68\x01"+
        "\x66\x02\uffff\x01\x2d\x01\x2b\x06\uffff\x02\x2e\x01\x72\x01\x30"+
        "\x05\uffff\x01\x6e\x01\x6c\x01\x64\x01\x73\x01\x74\x01\x61\x01\x69"+
        "\x01\x30\x06\uffff\x01\x2e\x01\x75\x01\uffff\x01\x30\x01\x63\x01"+
        "\x73\x01\x30\x01\x65\x01\x30\x01\x73\x01\x6c\x01\uffff\x01\x65\x01"+
        "\x30\x01\x65\x01\uffff\x01\x30\x01\uffff\x01\x73\x01\x65\x01\x30"+
        "\x01\uffff\x01\x30\x01\uffff\x02\x30\x03\uffff";
    const string DFA11_maxS =
        "\x01\x7d\x05\uffff\x01\x75\x01\x6e\x01\x65\x01\x6c\x01\x68\x01"+
        "\x66\x02\uffff\x01\x2d\x01\x2b\x06\uffff\x01\x2e\x01\x39\x01\x72"+
        "\x01\x7a\x05\uffff\x01\x6e\x01\x6c\x01\x64\x01\x73\x01\x74\x01\x61"+
        "\x01\x69\x01\x7a\x06\uffff\x01\x39\x01\x75\x01\uffff\x01\x7a\x01"+
        "\x63\x01\x73\x01\x7a\x01\x65\x01\x7a\x01\x73\x01\x6c\x01\uffff\x01"+
        "\x65\x01\x7a\x01\x65\x01\uffff\x01\x7a\x01\uffff\x01\x73\x01\x65"+
        "\x01\x7a\x01\uffff\x01\x7a\x01\uffff\x02\x7a\x03\uffff";
    const string DFA11_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x06\uffff\x01"+
        "\x0d\x01\x0e\x02\uffff\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01"+
        "\x18\x04\uffff\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x08\uffff"+
        "\x01\x0f\x01\x11\x01\x10\x01\x12\x01\x1a\x01\x19\x02\uffff\x01\x1c"+
        "\x08\uffff\x01\x0b\x03\uffff\x01\x07\x01\uffff\x01\x08\x03\uffff"+
        "\x01\x06\x01\uffff\x01\x0c\x02\uffff\x01\x1b\x01\x09\x01\x0a";
    const string DFA11_specialS =
        "\x4a\uffff}>";
    static readonly string[] DFA11_transitionS = {
            "\x01\x1d\x01\x1e\x02\uffff\x01\x1e\x12\uffff\x01\x1d\x01\x15"+
            "\x02\uffff\x01\x1b\x01\x12\x01\x13\x01\x1c\x01\x02\x01\x03\x01"+
            "\x10\x01\x0f\x01\x0c\x01\x0e\x01\x0d\x01\x11\x01\x16\x09\x17"+
            "\x03\uffff\x01\x01\x03\uffff\x1a\x19\x04\uffff\x01\x1a\x01\uffff"+
            "\x02\x1a\x01\x09\x01\x1a\x01\x07\x01\x06\x02\x1a\x01\x0b\x08"+
            "\x1a\x01\x08\x01\x1a\x01\x18\x02\x1a\x01\x0a\x03\x1a\x01\x04"+
            "\x01\x14\x01\x05",
            "",
            "",
            "",
            "",
            "",
            "\x01\x20\x13\uffff\x01\x1f",
            "\x01\x22\x01\uffff\x01\x21",
            "\x01\x23",
            "\x01\x24",
            "\x01\x25",
            "\x01\x26",
            "",
            "",
            "\x01\x27",
            "\x01\x29",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\x2c",
            "\x01\x2c\x01\uffff\x0a\x2d",
            "\x01\x2e",
            "\x0a\x30\x07\uffff\x1a\x30\x04\uffff\x01\x30\x01\uffff\x1a"+
            "\x30",
            "",
            "",
            "",
            "",
            "",
            "\x01\x31",
            "\x01\x32",
            "\x01\x33",
            "\x01\x34",
            "\x01\x35",
            "\x01\x36",
            "\x01\x37",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\x2c\x01\uffff\x0a\x2d",
            "\x01\x39",
            "",
            "\x0a\x30\x07\uffff\x1a\x30\x04\uffff\x01\x30\x01\uffff\x1a"+
            "\x30",
            "\x01\x3a",
            "\x01\x3b",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "\x01\x3d",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "\x01\x3f",
            "\x01\x40",
            "",
            "\x01\x41",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "\x01\x43",
            "",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "",
            "\x01\x45",
            "\x01\x46",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "\x0a\x1a\x07\uffff\x1a\x1a\x04\uffff\x01\x1a\x01\uffff\x1a"+
            "\x1a",
            "",
            "",
            ""
    };

    static readonly short[] DFA11_eot = DFA.UnpackEncodedString(DFA11_eotS);
    static readonly short[] DFA11_eof = DFA.UnpackEncodedString(DFA11_eofS);
    static readonly char[] DFA11_min = DFA.UnpackEncodedStringToUnsignedChars(DFA11_minS);
    static readonly char[] DFA11_max = DFA.UnpackEncodedStringToUnsignedChars(DFA11_maxS);
    static readonly short[] DFA11_accept = DFA.UnpackEncodedString(DFA11_acceptS);
    static readonly short[] DFA11_special = DFA.UnpackEncodedString(DFA11_specialS);
    static readonly short[][] DFA11_transition = DFA.UnpackEncodedStringArray(DFA11_transitionS);

    protected class DFA11 : DFA
    {
        public DFA11(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 11;
            this.eot = DFA11_eot;
            this.eof = DFA11_eof;
            this.min = DFA11_min;
            this.max = DFA11_max;
            this.accept = DFA11_accept;
            this.special = DFA11_special;
            this.transition = DFA11_transition;

        }

        override public string Description
        {
            get { return "1:1: Tokens : ( ASSIGN | LEFT_PAREN | RIGHT_PAREN | LEFT_BRACE | RIGHT_BRACE | FUNC | END | RET | CLASS | WHILE | IF | ELSE | COMMA | DOT | DECREMENT | INCREMENT | MINUS | PLUS | MULTIPLY | DIVIDE | MOD | AND | OR | NOT | FLOAT | INTEGER | BOOL_C | CLASS_NAME | NAME | INSTANCE_NAME | STRING_LITERAL | WHITESPACE | NEWLINE );"; }
        }

    }

 
    
}
}